#include <iostream>
#include <typeinfo>
#include <assert.h>
class Any
{
private:
	class holder
	{
	public:
		virtual ~holder() {}
		virtual const std::type_info &type() = 0;
		virtual holder *clone() = 0;
	};
	template <class T>
	class placeholder : public holder
	{
	public:
		placeholder(const T &val)
			: _val(val)
		{
		}
		virtual const std::type_info &type() // 获取数据类型
		{
			return typeid(T);
		}
		virtual holder *clone() // 针对当前类型对象，克隆一个新的子类对象
		{
			return new placeholder(_val);
		}

	public:
		T _val;
	};
	Any &swap(Any &other)
	{
		std::swap(_content, other._content);
		return *this;
	}

public:
	Any()
		: _content(nullptr)
	{
	}
	template <class T>
	Any(const T &val)
		: _content(new placeholder<T>(val))
	{
	}
	Any(const Any &other)
		: _content(other._content ? other._content->clone() : nullptr)
	{
	}
	~Any()
	{
		delete _content;
	}
	template <class T>
	T *get() // // 返回子类对象保存的数据的指针
	{
		// 要保证想获取的数据类型和数据保存的数据类型一致
		assert(typeid(T) == _content->type());
		return &((placeholder<T> *)_content)->_val;
	}
	template <class T>
	Any &operator=(const T &val) // 为赋值其他类型的数据
	{
		Any(val).swap(*this); // 创建临时对象，出作用域就会销毁原本的指针
		return *this;
	}
	Any &operator=(const Any &other) // 为赋值另一个Any的数据
	{
		Any(other).swap(*this);//临时对象离开作用域时，其析构函数 ~Any() 会调用 delete _content，释放的是当前对象原来持有的资源。
		return *this;
	}

private:
	holder *_content;
};

class task
{
public:
	task()
	{
		std::cout << "构造" << std::endl;
	}
	task(const task& t)
	{
		std::cout << "构造" << std::endl;
	}
	~task()
	{
		std::cout << "析构" << std::endl;
	}
};

int main()
{
	Any a;
	{
		Any t = task();
		// task t;
		a = t;
	}
	// Any a;
	// Any b(1);
	// std::cout << *b.get<int>() << std::endl;
	// Any c(1222);
	// b = std::string("saddsadsad");
	// std::cout << *b.get<std::string>() << std::endl;
	// b = c;
	// std::cout << *b.get<int>() << std::endl;
	// std::cout << *c.get<int>() << std::endl;
	return 0;
}